home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / helper / source / prnout.c < prev    next >
Text File  |  1991-10-18  |  18KB  |  694 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <stdarg.h>
  4. #include    <setjmp.h>
  5. #include    <fmc.h>
  6. #include    <mos.h>
  7. #include    "graphic.h"
  8. #include    "file.h"
  9. #include    "event.h"
  10. #include    "coldef.h"
  11.  
  12. #define    TRUE    1
  13. #define    FALSE    0
  14. #define    ERR    (-1)
  15.  
  16. #define    FUJITU        0
  17. #define    ESCP        1
  18.  
  19. #define    PRN_PAGE    0x80
  20. #define    PRN_KINSOKU    0x40
  21.  
  22. #define    TAB        8
  23.  
  24. int    PRN_putc(char ch);
  25. int    PRN_puts(char *str);
  26. int    PRN_open(int mod,int mspc,int lspc,int mrg,int mmax,int lmax);
  27. void    PRN_close(void);
  28.  
  29. void    PRN_char(char ch);
  30.  
  31. static jmp_buf    mark;
  32. static int    prnt_mod=0;
  33. static int    left_spc=4;
  34. static int    moji_spc=0;
  35. static int    line_spc=0;
  36. static int    moji_cnt=0;
  37. static int    line_cnt=0;
  38. static int    page_cnt=0;
  39. static int    moji_max=80;
  40. static int    line_max=59;
  41. static int    kanj_sft=0;
  42. static int    kanj_bak=0;
  43.  
  44. static int hantozen(unsigned char code)
  45. {
  46.     static unsigned short ank_tbl[]={
  47.         0x8140,0x8149,0x8168,0x8194,0x8190,0x8193,0x8195,0x8166,
  48.         0x8169,0x816A,0x8196,0x817B,0x8143,0x817C,0x8144,0x815E,
  49.         0x824F,0x8250,0x8251,0x8252,0x8253,0x8254,0x8255,0x8256,
  50.         0x8257,0x8258,0x8146,0x8147,0x8183,0x8181,0x8184,0x8148,
  51.         0x8197,0x8260,0x8261,0x8262,0x8263,0x8264,0x8265,0x8266,
  52.     0x8267,0x8268,0x8269,0x826A,0x826B,0x826C,0x826D,0x826E,
  53.         0x826F,0x8270,0x8271,0x8272,0x8273,0x8274,0x8275,0x8276,
  54.         0x8277,0x8278,0x8279,0x816D,0x818F,0x816E,0x814F,0x8151,
  55.         0x8166,0x8281,0x8282,0x8283,0x8284,0x8285,0x8286,0x8287,
  56.         0x8288,0x8289,0x828A,0x828B,0x828C,0x828D,0x828E,0x828F,
  57.         0x8290,0x8291,0x8292,0x8293,0x8294,0x8295,0x8296,0x8297,
  58.         0x8298,0x8299,0x829A,0x816F,0x8162,0x8170,0x8150,0x85A1 };
  59.     static unsigned short kana_tbl[]={
  60.         0x8140,0x8142,0x8175,0x8176,0x8141,0x8145,0x8392,0x8340,
  61.         0x8342,0x8344,0x8346,0x8348,0x8383,0x8385,0x8387,0x8362,
  62.         0x815B,0x8341,0x8343,0x8345,0x8347,0x8349,0x834A,0x834C,
  63.         0x834E,0x8350,0x8352,0x8354,0x8356,0x8358,0x835A,0x835C,
  64.         0x835E,0x8360,0x8363,0x8365,0x8367,0x8369,0x836A,0x836B,
  65.         0x836C,0x836D,0x836E,0x8371,0x8374,0x8377,0x837A,0x837D,
  66.         0x837E,0x8380,0x8381,0x8382,0x8384,0x8386,0x8388,0x8389,
  67.         0x838A,0x838B,0x838C,0x838D,0x838F,0x8393,0x814A,0x814B };
  68.  
  69.     if ( '\x20' <= code && code <= '\x7F' )
  70.         return ank_tbl[code-0x20];
  71.     else if ( '\xA0' <= code && code <= '\xDF' )
  72.     return kana_tbl[code-0xA0];
  73.     else
  74.         return 0x85A1;
  75. }
  76. static int     kinsoku(unsigned short i)
  77. {
  78.     if ( (prnt_mod & PRN_KINSOKU) == 0 )
  79.     return FALSE;
  80.  
  81.     if ( (i & 0xFF00) == 0 ) {
  82.         switch(i) {
  83.             case 0x27: case 0x29: case 0x2c: case 0x2e: case 0x3a:
  84.             case 0x3b: case 0x7d:
  85.             case 0xa1: case 0xa3: case 0xa4: case 0xde: case 0xdf:
  86.                 return TRUE;
  87.         }
  88.         return FALSE;
  89.     }
  90.  
  91.     if (i >= 0x8141 && i <= 0x814c)
  92.         return TRUE;
  93.     if (i >= 0x8165 && i <= 0x817a) {
  94.         if ((i % 2) == 0)
  95.             return TRUE;
  96.     }
  97.     switch(i) {
  98.         case 0x829f: case 0x82a1: case 0x82a3: case 0x82a5: case 0x82a7:
  99.         case 0x82c1: case 0x82e1: case 0x82e3: case 0x82e5: case 0x82ec:
  100.         case 0x8340: case 0x8342: case 0x8344: case 0x8346: case 0x8348:
  101.         case 0x8362: case 0x8383: case 0x8385: case 0x8387: case 0x838e:
  102.         case 0x8395: case 0x8396:
  103.             return TRUE;
  104.     }
  105.     return FALSE;
  106. }
  107. static void    PRN_byte(char ch)
  108. {
  109.     int     sts;
  110.  
  111.     while ( (sts = PRB_chr(ch)) != 0x00 ) {
  112.     if ( yesno("%s",
  113.         ( sts == 0x04 ? "プリンタに紙をセットしてください":
  114.         ( sts == 0x05 ? "プリンタをオンラインにしてください":
  115.         ( sts == 0x80 ? "プリンタの動作エラ－です":
  116.                     "プリンタに異常が発生しました")))) == ERR )
  117.         longjmp(mark,sts);
  118.     }
  119. }
  120. static void    PRN_word(short ch)
  121. {
  122.     PRN_byte(ch >> 8);
  123.     PRN_byte((char)ch);
  124. }
  125. static void    PRN_printf(char *form,...)
  126. {
  127.     va_list arg;
  128.     char    *p;
  129.     char    tmp[256];
  130.  
  131.     va_start(arg,form);
  132.     vsprintf(tmp,form,arg);
  133.     va_end(arg);
  134.  
  135.     for ( p = tmp ; *p != '\0' ; )
  136.     PRN_byte(*(p++));
  137. }
  138. static void    PRN_nprintf(int n,char *form,...)
  139. {
  140.     va_list arg;
  141.     char    *p;
  142.     char    tmp[256];
  143.  
  144.     va_start(arg,form);
  145.     vsprintf(tmp,form,arg);
  146.     va_end(arg);
  147.  
  148.     for ( p = tmp ; n > 0 ; n-- )
  149.     PRN_byte(*(p++));
  150. }
  151. static unsigned short    lin_cvt(unsigned short ch)
  152. {
  153.     int     i;
  154.     static struct {
  155.     unsigned short sjis;
  156.     unsigned short jis83;
  157.     } cnv_tbl[]={
  158.     { 0xEF88,    0x84a5 },    /*  */
  159.     { 0xEF89,    0x84a6 },    /*  */
  160.     { 0xEF8A,    0x84a7 },    /*  */
  161.     { 0xEF87,    0x84a8 },    /*  */
  162.     { 0xEF8B,    0x84a9 },    /*  */
  163.  
  164.     { 0xEF85,    0x849f },    /*  */
  165.     { 0xEF86,    0x84a0 },    /*  */
  166.     { 0xEF81,    0x84a1 },    /*  */
  167.     { 0xEF82,    0x84a2 },    /*  */
  168.     { 0xEF84,    0x84a3 },    /*  */
  169.     { 0xEF83,    0x84a4 },    /*  */
  170.  
  171.     { 0xEF64,    0x84aa },    /* d */
  172.     { 0xEF65,    0x84ab },    /* e */
  173.     { 0xEF60,    0x84ac },    /* ` */
  174.     { 0xEF61,    0x84ad },    /* a */
  175.     { 0xEF63,    0x84ae },    /* c */
  176.     { 0xEF62,    0x84af },    /* b */
  177.  
  178.     { 0xEF67,    0x84b0 },    /* g */
  179.     { 0xEF68,    0x84b1 },    /* h */
  180.     { 0xEF69,    0x84b2 },    /* i */
  181.     { 0xEF66,    0x84b3 },    /* f */
  182.     { 0xEF6A,    0x84b4 },    /* j */
  183.  
  184.     { 0xEF74,    0x84b5 },    /* t */
  185.     { 0xEF76,    0x84b6 },    /* v */
  186.     { 0xEF78,    0x84b7 },    /* x */
  187.     { 0xEF72,    0x84b8 },    /* r */
  188.     { 0xEF7A,    0x84b9 },    /* z */
  189.     { 0xEF95,    0x84ba },    /*  */
  190.     { 0xEF97,    0x84bb },    /*  */
  191.     { 0xEF99,    0x84bc },    /*  */
  192.     { 0xEF93,    0x84bd },    /*  */
  193.     { 0xEF9B,    0x84be },    /*  */
  194.  
  195.     { 0,0 } };
  196.  
  197.     for ( i = 0 ; cnv_tbl[i].sjis != 0 ; i++ ) {
  198.     if ( cnv_tbl[i].sjis == ch ) {
  199.         ch = cnv_tbl[i].jis83;
  200.         break;
  201.     }
  202.     }
  203.     return ch;
  204. }
  205. static void    PRN_kan_sub(short kan)
  206. {
  207.     switch(prnt_mod & 3) {
  208.     case FUJITU:
  209.     if ( kanj_sft == 0 )
  210.         PRN_printf("\x1b$B");    /* Kanji In */
  211.     kan = lin_cvt(kan);
  212.     PRN_word(sjistojis(kan));
  213.     break;
  214.  
  215.     case ESCP:
  216.     if ( kanj_sft == 0 )
  217.         PRN_printf("\x1c\x12");    /* Kanji in */
  218.     PRN_word(sjistojis(kan));
  219.     break;
  220.     }
  221.     kanj_sft = 1;
  222. }
  223. static void    PRN_ank_sub(char ank)
  224. {
  225.     switch(prnt_mod & 3) {
  226.     case FUJITU:
  227.     if ( kanj_sft != 0 )
  228.         PRN_printf("\x1b(H");    /* Kanji Out */
  229.     PRN_byte(ank);
  230.     break;
  231.  
  232.     case ESCP:
  233.     if ( kanj_sft != 0 )
  234.         PRN_printf("\x1c\x0f");    /* Kanji Out (use KANJI code) */
  235.     PRN_word(sjistojis(hantozen(ank)));
  236.     break;
  237.     }
  238.     kanj_sft = 0;
  239. }
  240. static void    PRN_left_spc(void)
  241. {
  242.     int     n;
  243.  
  244.     switch(prnt_mod & 3) {
  245.     case FUJITU:
  246.     PRN_printf("\x1bQ1 |");
  247.     break;
  248.     case ESCP:
  249.     PRN_printf("\x1c&\x1c\x0f");
  250.         kanj_sft = 0;
  251.     break;
  252.     }
  253.     for ( n = left_spc ; n > 0 ; n-- )
  254.     PRN_ank_sub(' ');
  255. }
  256. static void    PRN_page_spc(void)
  257. {
  258.     int     n;
  259.     char    tmp[32];
  260.  
  261.     if ( (prnt_mod & PRN_PAGE) == 0 )
  262.     goto ENDOF;
  263.  
  264.     while ( line_cnt++ <= line_max ) {
  265.     PRN_byte('\r');
  266.     PRN_byte('\n');
  267.     }
  268.  
  269.     PRN_left_spc();
  270.     for ( n = moji_max / 2 - 3 ; n > 0 ; n-- )
  271.     PRN_ank_sub(' ');
  272.     sprintf(tmp,"- %d -",++page_cnt);
  273.     for ( n = 0 ; tmp[n] != '\0' ; n++ )
  274.     PRN_ank_sub(tmp[n]);
  275.     PRN_byte('\r');
  276.     PRN_byte('\n');
  277.  
  278. ENDOF:
  279.  
  280.     PRN_byte('\x0C');
  281. }
  282. static void    PRN_kan(short kan)
  283. {
  284.     if ( (moji_cnt + 1) >= moji_max && !kinsoku(kan) ) {
  285.     PRN_char('\r');
  286.     PRN_char('\n');
  287.     }
  288.  
  289.     if ( moji_cnt == 0 )
  290.     PRN_left_spc();
  291.  
  292.     PRN_kan_sub(kan);
  293.  
  294.     moji_cnt += 2;
  295. }
  296. static void    PRN_ank(char ank)
  297. {
  298.     if ( moji_cnt >= moji_max && !kinsoku(ank) ) {
  299.     PRN_char('\r');
  300.     PRN_char('\n');
  301.     }
  302.  
  303.     if ( moji_cnt == 0 )
  304.     PRN_left_spc();
  305.  
  306.     PRN_ank_sub(ank);
  307.  
  308.     moji_cnt++;
  309. }
  310. static void    PRN_char(char ch)
  311. {
  312.     int     n;
  313.  
  314.     if ( kanj_bak != 0 ) {
  315.     if ( iskanji2(ch) ) {
  316.         n = (kanj_bak << 8) | (unsigned char)ch;
  317.         kanj_bak = 0;
  318.         PRN_kan(n);
  319.         return;
  320.     }
  321.     PRN_ank(kanj_bak);
  322.     kanj_bak = 0;
  323.     }
  324.  
  325.     if ( iskanji(ch) )
  326.     kanj_bak = ch;
  327.  
  328.     else if ( ch >= ' ' )
  329.     PRN_ank(ch);
  330.  
  331.     else if ( ch == '\r' ) {
  332.     PRN_byte(ch);
  333.     moji_cnt = 0;
  334.  
  335.     } else if ( ch == '\n' ) {
  336.     PRN_byte(ch);
  337.     moji_cnt = 0;
  338.     if ( ++line_cnt >= line_max )
  339.         PRN_char('\x0C');
  340.  
  341.     } else if ( ch == '\t' ) {
  342.     n = TAB - moji_cnt % TAB;
  343.     while ( n-- > 0 )
  344.         PRN_ank(' ');
  345.  
  346.     } else if ( ch == '\x0C' ) {
  347.     PRN_page_spc();
  348.     moji_cnt = line_cnt = 0;
  349.     }
  350. }
  351. int    PRN_putc(char ch)
  352. {
  353.     int     i;
  354.  
  355.     if ( (i = setjmp(mark)) != 0 )
  356.     return ERR;
  357.  
  358.     PRN_char(ch);
  359.  
  360.     return FALSE;
  361. }
  362. int    PRN_puts(char *str)
  363. {
  364.     int     i;
  365.  
  366.     if ( (i = setjmp(mark)) != 0 )
  367.     return ERR;
  368.  
  369. /******************************
  370.     while ( *str != '\0' ) {
  371.     if ( *str == '\n' )
  372.         PRN_char('\r');
  373.     PRN_char(*(str++));
  374.     }
  375. *******************************/
  376.  
  377.     while ( *str != '\0' )
  378.     PRN_char(*(str++));
  379.  
  380.     PRN_char('\r');
  381.     PRN_char('\n');
  382.  
  383.     return FALSE;
  384. }
  385. void    PRN_file(char *file)
  386. {
  387.     int     ch;
  388.     FILE    *fp;
  389.  
  390.     if ( setjmp(mark) != 0 )
  391.     return;
  392.  
  393.     if ( (fp = fopen(file,"r")) == NULL )
  394.     return;
  395.  
  396.     while ( (ch = getc(fp)) != EOF ) {
  397.     if ( ch == '\n' )
  398.         PRN_char('\r');
  399.     PRN_char(ch);
  400.     }
  401.  
  402.     fclose(fp);
  403. }
  404. int    PRN_open(int mod,int mspc,int lspc,int mrg,int mmax,int lmax)
  405. {
  406.     int     i;
  407.  
  408.     prnt_mod = mod;
  409.     moji_spc = mspc;
  410.     line_spc = lspc;
  411.     moji_max = mmax;
  412.     line_max = lmax;
  413.     left_spc = mrg;
  414.     moji_cnt = line_cnt = page_cnt = 0;
  415.     kanj_sft = kanj_bak = 0;
  416.  
  417.     if ( (i = setjmp(mark)) != 0 )
  418.     return ERR;
  419.  
  420.     switch(prnt_mod & 3) {
  421.     case FUJITU:
  422.     PRN_printf("\x1bQ3 \x5c");
  423.     i = moji_spc + 24;
  424.     PRN_printf("\x1c$%c%c",i/10+0x20,i%10+0x70);
  425.     i = line_spc + 24;
  426.     PRN_printf("\x1c%%%c%c\x1b(H",i/10+0x20,i%10+0x70);
  427.     break;
  428.  
  429.     case ESCP:
  430.     i = moji_spc / 2;
  431.     PRN_nprintf(4,"\x1cS%c%c",i,moji_spc-i);
  432.     i = (moji_spc + 24) / 2 - 11;
  433.     PRN_nprintf(4,"\x1cT%c%c",i/2,i-i/2);
  434.     PRN_printf("%s",(moji_spc & 1) != 0 ? "\x1cU":"\x1cV");
  435.     PRN_nprintf(3,"\x1b\x33%c",line_spc+24);
  436.     PRN_printf("\x1c\x0f");
  437.     break;
  438.     }
  439.  
  440.     return FALSE;
  441. }
  442. void    PRN_close(void)
  443. {
  444.     if ( line_cnt > 0 )
  445.     PRN_putc('\x0C');
  446. }
  447.  
  448. /**************************************************************
  449.  
  450. 01234567890123456789012345678901234567890123456789012345678901234567890123456789               012345678901234567890123456789012345678901234567890123
  451. 0          +----------------------------------------------------+
  452. 1          |                                                    |
  453. 2          |           テキスト印刷の設定および印刷             |
  454. 3          |                                                    |
  455. 4          | 用 紙  選 択  A4  B4  B5       +----------------+  |
  456. 5          | １行の文字数  ＜ 000 ＞        | +------------+ |  |
  457. 6          | １ペ－ジ行数  ＜ 000 ＞        | |            | |  |
  458. 7          | 左余白文字数  ＜ 000 ＞        | |            | |  |
  459. 8          | 文 字  間 隔  ＜ 000 ＞        | |            | |  |
  460. 9          |   行   間 隔  ＜ 000 ＞        | +------------+ |  |
  461. 10         | ﾌﾟﾘﾝﾀの種 類  FM系 ESCP系      +----------------+  |
  462. 11         |                                                    |
  463. 12         |                | 印  刷 | | 取  消 |               |
  464. 13         |                                                    |
  465. 14         +----------------------------------------------------+
  466.  
  467. *****************************************************************/
  468.  
  469. #define    LPT_X1        (15*8-4)
  470. #define    LPT_Y1        (240-7*22)
  471. #define    LPT_X2        (65*8+3)
  472. #define    LPT_Y2        (LPT_Y1+12*22)
  473.  
  474. #define    LPT_MSG_X    (LPT_X1+12*8)
  475. #define    LPT_MSG_Y    (LPT_Y1+1*22)
  476.  
  477. #define    LPT_PAP_X    (LPT_X1+2*8)
  478. #define    LPT_PAP_Y    (LPT_Y1+3*22)
  479.  
  480. #define    LPT_MMX_X    (LPT_X1+2*8)
  481. #define    LPT_MMX_Y    (LPT_Y1+4*22)
  482.  
  483. #define    LPT_LMX_X    (LPT_X1+2*8)
  484. #define    LPT_LMX_Y    (LPT_Y1+5*22)
  485.  
  486. #define    LPT_MRG_X    (LPT_X1+2*8)
  487. #define    LPT_MRG_Y    (LPT_Y1+6*22)
  488.  
  489. #define    LPT_MSC_X    (LPT_X1+2*8)
  490. #define    LPT_MSC_Y    (LPT_Y1+7*22)
  491.  
  492. #define    LPT_LSC_X    (LPT_X1+2*8)
  493. #define    LPT_LSC_Y    (LPT_Y1+8*22)
  494.  
  495. #define    LPT_MOD_X    (LPT_X1+2*8)
  496. #define    LPT_MOD_Y    (LPT_Y1+9*22)
  497.  
  498. #define    LPT_YES_X    ((LPT_X1+LPT_X2)/2-(10*8))
  499. #define    LPT_YES_Y    (LPT_Y1+11*22-8)
  500.  
  501. #define    LPT_NO_X    ((LPT_X1+LPT_X2)/2+(2*8))
  502. #define    LPT_NO_Y    (LPT_Y1+11*22-8)
  503.  
  504. #define    LPT_IMG_X    (LPT_X1+32*8)
  505. #define    LPT_IMG_Y    (LPT_Y1+3*22)
  506.  
  507. int    LPT_open(void)
  508. {
  509.     int    sw,bx,by;
  510.     int    cd,x1,x2,y1,y2;
  511.     BLOCK  *sp;
  512.     EVENT  *ep=NULL;
  513.     static int     pap=0,mod=0;
  514.     static struct {
  515.     int    mmx,lmx,mrg,msc,lsc;
  516.     int    yoko,tate;
  517.     } you[3]={
  518.     {  80,59,10,4,6,1494,2106 },    /* A4 */
  519.     {  80,48, 4,4,6,1296,1818 },    /* B4 */
  520.     { 100,74,12,4,6,1818,2592 },
  521.     };
  522.     static struct {
  523.     int    yofs,tofs;
  524.     } prn[2]={
  525.     { 63,144 },{ 0,177 },
  526.     };
  527.  
  528.     MOS_disp(OFF);
  529.     sp = DSP_push_vram(LPT_X1,LPT_Y1,LPT_X2,LPT_Y2);
  530.     DSP_opbox(LPT_X1,LPT_Y1,LPT_X2,LPT_Y2);
  531.     DSP_wbox(LPT_X1,LPT_Y1,LPT_X2,LPT_Y2,LINE_COL,FILD_COL,M_PSET);
  532.  
  533.     gputs(LPT_MSG_X,LPT_MSG_Y,CHR_COL,FILD_COL,"テキスト印刷の設定および印刷");
  534.     gputs(LPT_PAP_X,LPT_PAP_Y,CHR_COL,FILD_COL,"用 紙  選 択");
  535.     gputs(LPT_MMX_X,LPT_MMX_Y,CHR_COL,FILD_COL,"１行の文字数");
  536.     gputs(LPT_LMX_X,LPT_LMX_Y,CHR_COL,FILD_COL,"１ペ－ジ行数");
  537.     gputs(LPT_MRG_X,LPT_MRG_Y,CHR_COL,FILD_COL,"左余白文字数");
  538.     gputs(LPT_MSC_X,LPT_MSC_Y,CHR_COL,FILD_COL,"文 字  間 隔");
  539.     gputs(LPT_LSC_X,LPT_LSC_Y,CHR_COL,FILD_COL,"  行   間 隔");
  540.     gputs(LPT_MOD_X,LPT_MOD_Y,CHR_COL,FILD_COL,"ﾌﾟﾘﾝﾀの種 類");
  541.  
  542.     ep = EVT_sw(ep,0,LPT_PAP_X+14*8,LPT_PAP_Y,CHR_COL,WIND_COL,"A4");
  543.     ep = EVT_sw(ep,1,LPT_PAP_X+18*8,LPT_PAP_Y,CHR_COL,WIND_COL,"B5");
  544.     ep = EVT_sw(ep,2,LPT_PAP_X+22*8,LPT_PAP_Y,CHR_COL,WIND_COL,"B4");
  545.  
  546.     ep = EVT_sw(ep,3,LPT_MMX_X+14*8,LPT_MMX_Y,CHR_COL,WIND_COL,"＜");
  547.     ep = EVT_sw(ep,4,LPT_MMX_X+21*8,LPT_MMX_Y,CHR_COL,WIND_COL,"＞");
  548.  
  549.     ep = EVT_sw(ep,5,LPT_LMX_X+14*8,LPT_LMX_Y,CHR_COL,WIND_COL,"＜");
  550.     ep = EVT_sw(ep,6,LPT_LMX_X+21*8,LPT_LMX_Y,CHR_COL,WIND_COL,"＞");
  551.  
  552.     ep = EVT_sw(ep,7,LPT_MRG_X+14*8,LPT_MRG_Y,CHR_COL,WIND_COL,"＜");
  553.     ep = EVT_sw(ep,8,LPT_MRG_X+21*8,LPT_MRG_Y,CHR_COL,WIND_COL,"＞");
  554.  
  555.     ep = EVT_sw(ep,9,LPT_MSC_X+14*8,LPT_MSC_Y,CHR_COL,WIND_COL,"＜");
  556.     ep = EVT_sw(ep,10,LPT_MSC_X+21*8,LPT_MSC_Y,CHR_COL,WIND_COL,"＞");
  557.  
  558.     ep = EVT_sw(ep,11,LPT_LSC_X+14*8,LPT_LSC_Y,CHR_COL,WIND_COL,"＜");
  559.     ep = EVT_sw(ep,12,LPT_LSC_X+21*8,LPT_LSC_Y,CHR_COL,WIND_COL,"＞");
  560.  
  561.     ep = EVT_sw(ep,13,LPT_MOD_X+14*8,LPT_MOD_Y,CHR_COL,WIND_COL,"FM系");
  562.     ep = EVT_sw(ep,14,LPT_MOD_X+20*8,LPT_MOD_Y,CHR_COL,WIND_COL,"ESCP系");
  563.  
  564.     ep = EVT_sw(ep,15,LPT_YES_X,LPT_YES_Y,CHR_COL,WIND_COL," 印  刷");
  565.     ep = EVT_sw(ep,16,LPT_NO_X,LPT_NO_Y,CHR_COL,WIND_COL," 取  消 ");
  566.  
  567.     MOS_rdpos(&sw,&bx,&by);
  568.     MOS_setpos((LPT_X1+LPT_X2)/2,(LPT_Y1+LPT_Y2)/2);
  569.     MOS_disp(ON);
  570.  
  571.     for ( cd = FALSE ; cd == FALSE ; ) {
  572.     MOS_disp(OFF);
  573.  
  574.     gprintf(LPT_PAP_X+14*8,LPT_PAP_Y,
  575.             pap != 0 ? CHR_COL:XERR_COL,WIND_COL,"A4");
  576.     gprintf(LPT_PAP_X+18*8,LPT_PAP_Y,
  577.             pap != 1 ? CHR_COL:XERR_COL,WIND_COL,"B5");
  578.     gprintf(LPT_PAP_X+22*8,LPT_PAP_Y,
  579.             pap != 2 ? CHR_COL:XERR_COL,WIND_COL,"B4");
  580.  
  581.     gprintf(LPT_MMX_X+17*8,LPT_MMX_Y,CHR_COL,FILD_COL,"%3d",you[pap].mmx);
  582.     gprintf(LPT_LMX_X+17*8,LPT_LMX_Y,CHR_COL,FILD_COL,"%3d",you[pap].lmx);
  583.     gprintf(LPT_MRG_X+17*8,LPT_MRG_Y,CHR_COL,FILD_COL,"%3d",you[pap].mrg);
  584.     gprintf(LPT_MSC_X+17*8,LPT_MSC_Y,CHR_COL,FILD_COL,"%3d",you[pap].msc);
  585.     gprintf(LPT_LSC_X+17*8,LPT_LSC_Y,CHR_COL,FILD_COL,"%3d",you[pap].lsc);
  586.  
  587.     gprintf(LPT_MOD_X+14*8,LPT_MOD_Y,
  588.             mod != 0 ? CHR_COL:XERR_COL,WIND_COL,"FM系");
  589.     gprintf(LPT_MOD_X+20*8,LPT_MOD_Y,
  590.             mod != 1 ? CHR_COL:XERR_COL,WIND_COL,"ESCP系");
  591.  
  592.     DSP_box(LPT_IMG_X,LPT_IMG_Y,LPT_IMG_X+120,LPT_IMG_Y+150,
  593.             FILD_COL,M_PSET);
  594.  
  595.     x1 = 0;
  596.     y1 = 0;
  597.     x2 = you[pap].yoko;
  598.     y2 = you[pap].tate;
  599.  
  600.     x1 = x1 / 18 + LPT_IMG_X;
  601.     y1 = y1 / 18 + LPT_IMG_Y;
  602.     x2 = x2 / 18 + LPT_IMG_X;
  603.     y2 = y2 / 18 + LPT_IMG_Y;
  604.     DSP_rbox(x1,y1,x2,y2,LINE_COL,WIND_COL,M_PSET);
  605.  
  606.     x1 = prn[mod].yofs + (you[pap].mrg*(24+you[pap].msc)/2);
  607.     y1 = prn[mod].tofs;
  608.     x2 = x1 + (you[pap].mmx*(24+you[pap].msc)/2);
  609.     y2 = y1 + (you[pap].lmx*(24+you[pap].lsc));
  610.  
  611.     x1 = x1 / 18 + LPT_IMG_X;
  612.     y1 = y1 / 18 + LPT_IMG_Y;
  613.     x2 = x2 / 18 + LPT_IMG_X;
  614.     y2 = y2 / 18 + LPT_IMG_Y;
  615.     DSP_box(x1,y1,x2,y2,XWIND_COL,M_PSET);
  616.  
  617.     MOS_disp(ON);
  618.  
  619.     switch(EVT_wait(ep)) {
  620.     case 0: pap = 0; break;
  621.     case 1: pap = 1; break;
  622.     case 2: pap = 2; break;
  623.  
  624.     case 3:
  625.         if ( you[pap].mmx > 1 )
  626.         you[pap].mmx--;
  627.         break;
  628.     case 4:
  629.         if ( you[pap].yoko > 
  630.     (prn[mod].yofs+(you[pap].mrg+you[pap].mmx+1)*(24+you[pap].msc)/2) )
  631.         you[pap].mmx++;
  632.         break;
  633.  
  634.     case 5:
  635.         if ( you[pap].lmx > 3 )
  636.         you[pap].lmx--;
  637.         break;
  638.     case 6:
  639.         if ( you[pap].tate >
  640.         (prn[mod].tofs+(you[pap].lmx+1)*(24+you[pap].lsc)) )
  641.         you[pap].lmx++;
  642.         break;
  643.  
  644.     case 7:
  645.         if ( you[pap].mrg > 0 )
  646.         you[pap].mrg--;
  647.         break;
  648.     case 8:
  649.         if ( you[pap].yoko > 
  650.     (prn[mod].yofs+(you[pap].mrg+you[pap].mmx+1)*(24+you[pap].msc)/2) )
  651.         you[pap].mrg++;
  652.         break;
  653.  
  654.     case 9:
  655.         if ( you[pap].msc > 0 )
  656.         you[pap].msc--;
  657.         break;
  658.     case 10:
  659.         if ( you[pap].yoko > 
  660.     (prn[mod].yofs+(you[pap].mrg+you[pap].mmx)*(24+you[pap].msc+1)/2) )
  661.         you[pap].msc++;
  662.         break;
  663.  
  664.     case 11:
  665.         if ( you[pap].lsc > 0 )
  666.         you[pap].lsc--;
  667.         break;
  668.     case 12:
  669.         if ( you[pap].tate >
  670.         (prn[mod].tofs+you[pap].lmx*(24+you[pap].lsc+1)) )
  671.         you[pap].lsc++;
  672.         break;
  673.  
  674.     case 13: mod = FUJITU; break;
  675.     case 14: mod = ESCP;   break;
  676.  
  677.     case 15: cd = TRUE; break;
  678.     case 16: cd = ERR;  break;
  679.     }
  680.     }
  681.  
  682.     EVT_free(ep);
  683.     MOS_disp(OFF);
  684.     DSP_pop_vram(sp);
  685.     DSP_clbox(LPT_X1,LPT_Y1,LPT_X2,LPT_Y2);
  686.     MOS_setpos(bx,by);
  687.     MOS_disp(ON);
  688.  
  689.     if ( cd == TRUE )
  690.     return PRN_open(mod|0x80,you[pap].msc,you[pap].lsc,you[pap].mrg,
  691.         you[pap].mmx,you[pap].lmx-2);
  692.     return ERR;
  693. }
  694.